const vscode = require('vscode');
const HttpServerManager = require('./httpServer');
const { ProxyServerManager } = require('./proxyServer');
const globalServerManager = require('./globalServerManager');
const {  logError, logDebug, logInfo } = require('./logger');
const path = require('path');
const fs = require('fs');

/**
 * 工作空间服务器管理器
 * 管理每个workspace对应的HttpServerManager和ProxyServerManager实例
 */
class WorkspaceServerManager {
    constructor() {
        // 存储每个workspace的服务器实例
        // Map<workspacePath, {httpServer, proxyServer}>
        this.workspaceServers = new Map();
        
        // 监听工作空间文件夹变化
        this.setupWorkspaceListeners();
        
        logInfo('工作空间服务器管理器已初始化');
    }

    /**
     * 设置工作空间监听器
     */
    setupWorkspaceListeners() {
        // 监听工作空间文件夹变化
        vscode.workspace.onDidChangeWorkspaceFolders((event) => {
            logInfo('工作空间文件夹变化事件触发');
            
            // 处理移除的工作空间
            event.removed.forEach(folder => {
                const workspacePath = folder.uri.fsPath;
                logInfo(`移除工作空间: ${workspacePath}`);
                this.stopWorkspaceServers(workspacePath);
            });
            
            // 处理新增的工作空间
            event.added.forEach(folder => {
                const workspacePath = folder.uri.fsPath;
                logInfo(`新增工作空间: ${workspacePath}`);
                this.startWorkspaceServers(workspacePath);
            });
        });
    }

    /**
     * 检查package.json配置是否满足启动条件
     * @param {string} workspacePath 工作空间路径
     * @returns {boolean} 是否满足启动条件
     */
    checkPackageConfig(workspacePath) {
        try {
            const packagePath = path.join(workspacePath, 'package.json');
            
            // 检查文件是否存在
            if (!fs.existsSync(packagePath)) {
                logInfo(`工作空间 ${workspacePath} 的package.json文件不存在，不满足启动条件`);
                return false;
            }
            
            const packageContent = fs.readFileSync(packagePath, 'utf8');
            const packageJson = JSON.parse(packageContent);
            
            // 检查name字段是否存在
            if (!packageJson.name) {
                logInfo(`工作空间 ${workspacePath} 的package.json中缺少name字段，不满足启动条件`);
                return false;
            }
            
            if (packageJson.name === 'guandata-web') {
                logInfo(`工作空间 ${workspacePath} 检测到包名为guandata-web，满足启动条件`);
                return true;
            } else {
                logInfo(`工作空间 ${workspacePath} 当前包名为: ${packageJson.name}，不满足启动条件(需要: guandata-web)`);
                return false;
            }
        } catch (error) {
            console.error(`读取工作空间 ${workspacePath} 的package.json失败:`, error);
            return false;
        }
    }

    /**
     * 启动指定工作空间的服务器
     * @param {string} workspacePath 工作空间路径
     */
    async startWorkspaceServers(workspacePath) {
        try {
            logDebug(`开始检查工作空间 ${workspacePath}`);
            
            // 检查是否已经有服务器实例
            const hasExistingServer = this.workspaceServers.has(workspacePath);
            logDebug(`工作空间 ${workspacePath} 是否已有服务器: ${hasExistingServer}`);
            
            if (hasExistingServer) {
                logInfo(`工作空间 ${workspacePath} 的服务器已存在，跳过启动`);
                return;
            }

            // 检查package.json配置
            logDebug(`开始检查 ${workspacePath} 的package.json配置`);
            const configValid = this.checkPackageConfig(workspacePath);
            logDebug(`package.json配置检查结果: ${configValid}`);
            
            if (!configValid) {
                logInfo(`工作空间 ${workspacePath} 不满足启动条件，跳过启动服务器`);
                return;
            }

            logInfo(`开始启动工作空间 ${workspacePath} 的服务器`);

            // 创建HTTP服务器实例
            const httpServer = new HttpServerManager(workspacePath);
            
            // 创建代理服务器实例
            const proxyServer = new ProxyServerManager(workspacePath);

            // 启动HTTP服务器
            const httpPort = await httpServer.start();
            logInfo(`工作空间 ${workspacePath} 的HTTP API服务已在端口 ${httpPort} 启动`);
            
            // 注册到全局管理器
            globalServerManager.registerServer(workspacePath, httpServer);
            logInfo(`工作空间 ${workspacePath} 的HTTP服务已注册到全局管理器，端口: ${httpPort}`);

            // 启动代理服务器
            const proxyPort = await proxyServer.start();
            logInfo(`工作空间 ${workspacePath} 的API代理服务已在端口 ${proxyPort} 启动`);

            // 保存服务器实例
            this.workspaceServers.set(workspacePath, {
                httpServer,
                proxyServer,
                httpPort,
                proxyPort
            });

            logInfo(`工作空间 ${workspacePath} 的服务器启动完成`);

        } catch (error) {
            logError(`启动工作空间 ${workspacePath} 的服务器失败`, error);
            vscode.window.showErrorMessage(`启动工作空间服务器失败: ${error.message}`);
        }
    }

    /**
     * 停止指定工作空间的服务器
     * @param {string} workspacePath 工作空间路径
     */
    async stopWorkspaceServers(workspacePath) {
        try {
            const servers = this.workspaceServers.get(workspacePath);
            if (!servers) {
                logInfo(`工作空间 ${workspacePath} 没有运行的服务器`);
                return;
            }

            logInfo(`开始停止工作空间 ${workspacePath} 的服务器`);

            // 从全局管理器注销HTTP服务器
            globalServerManager.unregisterServer(workspacePath);

            // 停止HTTP服务器
            if (servers.httpServer) {
                servers.httpServer.stop();
                logInfo(`工作空间 ${workspacePath} 的HTTP服务器已停止`);
            }

            // 停止代理服务器
            if (servers.proxyServer) {
                servers.proxyServer.stop();
                logInfo(`工作空间 ${workspacePath} 的代理服务器已停止`);
            }

            // 从映射中移除
            this.workspaceServers.delete(workspacePath);

            logInfo(`工作空间 ${workspacePath} 的服务器停止完成`);

        } catch (error) {
            console.error(`停止工作空间 ${workspacePath} 的服务器失败:`, error);
        }
    }

    /**
     * 启动所有当前工作空间的服务器
     */
    async startAllWorkspaceServers() {
        if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0) {
            logInfo('没有打开的工作空间');
            return;
        }

        logInfo('开始启动所有工作空间的服务器');

        for (const folder of vscode.workspace.workspaceFolders) {
            const workspacePath = folder.uri.fsPath;
            await this.startWorkspaceServers(workspacePath);
        }

        logInfo('所有工作空间服务器启动完成');
    }

    /**
     * 停止所有工作空间的服务器
     */
    async stopAllWorkspaceServers() {
        logInfo('开始停止所有工作空间的服务器');

        const workspacePaths = Array.from(this.workspaceServers.keys());
        for (const workspacePath of workspacePaths) {
            await this.stopWorkspaceServers(workspacePath);
        }

        logInfo('所有工作空间服务器停止完成');
    }

    /**
     * 获取指定工作空间的服务器实例
     * @param {string} workspacePath 工作空间路径
     * @returns {Object|null} 服务器实例对象或null
     */
    getWorkspaceServers(workspacePath) {
        return this.workspaceServers.get(workspacePath) || null;
    }

    /**
     * 获取所有工作空间的服务器实例
     * @returns {Map} 所有服务器实例的映射
     */
    getAllWorkspaceServers() {
        return new Map(this.workspaceServers);
    }

    /**
     * 重启指定工作空间的服务器
     * @param {string} workspacePath 工作空间路径
     */
    async restartWorkspaceServers(workspacePath) {
        logInfo(`重启工作空间 ${workspacePath} 的服务器`);
        await this.stopWorkspaceServers(workspacePath);
        await this.startWorkspaceServers(workspacePath);
    }
}

// 创建单例实例
let workspaceServerManagerInstance = null;

function getWorkspaceServerManager() {
    if (!workspaceServerManagerInstance) {
        workspaceServerManagerInstance = new WorkspaceServerManager();
    }
    return workspaceServerManagerInstance;
}

module.exports = {
    WorkspaceServerManager,
    getWorkspaceServerManager
}; 